// $ANTLR 2.7.7 (20060930): "RelatedItemsQuery.g" -> "QueryParser.cs"$


namespace SearchTools.QueryParser
{
	// Generate the header common to all output files.
	using System;
	
	using TokenBuffer              = antlr.TokenBuffer;
	using TokenStreamException     = antlr.TokenStreamException;
	using TokenStreamIOException   = antlr.TokenStreamIOException;
	using ANTLRException           = antlr.ANTLRException;
	using LLkParser = antlr.LLkParser;
	using Token                    = antlr.Token;
	using IToken                   = antlr.IToken;
	using TokenStream              = antlr.TokenStream;
	using RecognitionException     = antlr.RecognitionException;
	using NoViableAltException     = antlr.NoViableAltException;
	using MismatchedTokenException = antlr.MismatchedTokenException;
	using SemanticException        = antlr.SemanticException;
	using ParserSharedInputState   = antlr.ParserSharedInputState;
	using BitSet                   = antlr.collections.impl.BitSet;
	using AST                      = antlr.collections.AST;
	using ASTPair                  = antlr.ASTPair;
	using ASTFactory               = antlr.ASTFactory;
	using ASTArray                 = antlr.collections.impl.ASTArray;
	
	public 	class QueryParser : antlr.LLkParser
	{
		public const int EOF = 1;
		public const int NULL_TREE_LOOKAHEAD = 3;
		public const int CLAUSE = 4;
		public const int TERM = 5;
		public const int PREFIX = 6;
		public const int BOOST = 7;
		public const int FUZZY = 8;
		public const int RANGE = 9;
		public const int QUALIFIEDTERM = 10;
		public const int UNQUALIFIEDTERM = 11;
		public const int INJECTMETA = 12;
		public const int SIMILARTO = 13;
		public const int EXPANDSYNONYMS = 14;
		public const int REF = 15;
		public const int AND = 16;
		public const int OR = 17;
		public const int PLUS = 18;
		public const int MINUS = 19;
		public const int OPEN_PAREN = 20;
		public const int CLOSE_PAREN = 21;
		public const int CARET = 22;
		public const int TILDE = 23;
		public const int HASH = 24;
		public const int LITERAL_injectmeta = 25;
		public const int COMMA = 26;
		public const int IDENT = 27;
		public const int LITERAL_similarto = 28;
		public const int COLON = 29;
		public const int STRING_LITERAL = 30;
		public const int NUM_INT = 31;
		public const int NUM_DOUBLE = 32;
		public const int NUM_FLOAT = 33;
		public const int OPEN_SQUARE = 34;
		public const int TO = 35;
		public const int CLOSE_SQUARE = 36;
		public const int NOT = 37;
		public const int DOLLAR = 38;
		public const int WS = 39;
		public const int CHAR_LITERAL = 40;
		public const int ESC = 41;
		public const int HEX_DIGIT = 42;
		public const int EXPONENT = 43;
		public const int FLOAT_SUFFIX = 44;
		public const int NUM_LONG = 45;
		public const int DOT = 46;
		
		
		protected void initialize()
		{
			tokenNames = tokenNames_;
			initializeFactory();
		}
		
		
		protected QueryParser(TokenBuffer tokenBuf, int k) : base(tokenBuf, k)
		{
			initialize();
		}
		
		public QueryParser(TokenBuffer tokenBuf) : this(tokenBuf,3)
		{
		}
		
		protected QueryParser(TokenStream lexer, int k) : base(lexer,k)
		{
			initialize();
		}
		
		public QueryParser(TokenStream lexer) : this(lexer,3)
		{
		}
		
		public QueryParser(ParserSharedInputState state) : base(state,3)
		{
			initialize();
		}
		
	public void query() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST query_AST = null;
		
		{    // ( ... )*
			for (;;)
			{
				if ((tokenSet_0_.member(LA(1))))
				{
					clause();
					astFactory.addASTChild(ref currentAST, returnAST);
					{
						switch ( LA(1) )
						{
						case AND:
						{
							{
								AST tmp1_AST = null;
								tmp1_AST = astFactory.create(LT(1));
								astFactory.makeASTRoot(ref currentAST, tmp1_AST);
								match(AND);
								clause();
								astFactory.addASTChild(ref currentAST, returnAST);
							}
							break;
						}
						case OR:
						{
							{
								AST tmp2_AST = null;
								tmp2_AST = astFactory.create(LT(1));
								astFactory.makeASTRoot(ref currentAST, tmp2_AST);
								match(OR);
								clause();
								astFactory.addASTChild(ref currentAST, returnAST);
							}
							break;
						}
						case EOF:
						case PLUS:
						case MINUS:
						case OPEN_PAREN:
						case HASH:
						case IDENT:
						case STRING_LITERAL:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						 }
					}
				}
				else
				{
					goto _loop6_breakloop;
				}
				
			}
_loop6_breakloop:			;
		}    // ( ... )*
		match(Token.EOF_TYPE);
		query_AST = currentAST.root;
		returnAST = query_AST;
	}
	
	public void clause() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST clause_AST = null;
		AST s_AST = null;
		AST e_AST = null;
		AST b_AST = null;
		
		{
			switch ( LA(1) )
			{
			case PLUS:
			case MINUS:
			case OPEN_PAREN:
			{
				subClause();
				s_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				break;
			}
			case HASH:
			case IDENT:
			case STRING_LITERAL:
			{
				expression();
				e_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				clause_AST = (AST)currentAST.root;
				clause_AST = (AST) astFactory.make(astFactory.create(CLAUSE,"CLAUSE"), e_AST);
				currentAST.root = clause_AST;
				if ( (null != clause_AST) && (null != clause_AST.getFirstChild()) )
					currentAST.child = clause_AST.getFirstChild();
				else
					currentAST.child = clause_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			 }
		}
		{
			if ((LA(1)==CARET) && ((LA(2) >= NUM_INT && LA(2) <= NUM_FLOAT)) && (tokenSet_1_.member(LA(3))))
			{
				boost();
				b_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				clause_AST = (AST)currentAST.root;
				clause_AST = (AST) astFactory.make(astFactory.create(BOOST,"BOOST"), clause_AST);
				currentAST.root = clause_AST;
				if ( (null != clause_AST) && (null != clause_AST.getFirstChild()) )
					currentAST.child = clause_AST.getFirstChild();
				else
					currentAST.child = clause_AST;
				currentAST.advanceChildToEnd();
			}
			else if ((tokenSet_1_.member(LA(1))) && (tokenSet_2_.member(LA(2))) && (tokenSet_3_.member(LA(3)))) {
			}
			else
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		clause_AST = currentAST.root;
		returnAST = clause_AST;
	}
	
	public void subClause() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST subClause_AST = null;
		AST c_AST = null;
		
		{
			switch ( LA(1) )
			{
			case PLUS:
			{
				{
					AST tmp4_AST = null;
					tmp4_AST = astFactory.create(LT(1));
					astFactory.makeASTRoot(ref currentAST, tmp4_AST);
					match(PLUS);
					clause();
					astFactory.addASTChild(ref currentAST, returnAST);
				}
				break;
			}
			case MINUS:
			{
				{
					AST tmp5_AST = null;
					tmp5_AST = astFactory.create(LT(1));
					astFactory.makeASTRoot(ref currentAST, tmp5_AST);
					match(MINUS);
					clause();
					astFactory.addASTChild(ref currentAST, returnAST);
				}
				break;
			}
			case OPEN_PAREN:
			{
				{
					match(OPEN_PAREN);
					clause();
					c_AST = (AST)returnAST;
					astFactory.addASTChild(ref currentAST, returnAST);
					match(CLOSE_PAREN);
				}
				subClause_AST = (AST)currentAST.root;
				
								//Create subtree for this clause
								subClause_AST = (AST) astFactory.make(astFactory.create(CLAUSE,"CLAUSE"), c_AST);
							
				currentAST.root = subClause_AST;
				if ( (null != subClause_AST) && (null != subClause_AST.getFirstChild()) )
					currentAST.child = subClause_AST.getFirstChild();
				else
					currentAST.child = subClause_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			 }
		}
		subClause_AST = currentAST.root;
		returnAST = subClause_AST;
	}
	
	public void expression() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST expression_AST = null;
		
		switch ( LA(1) )
		{
		case HASH:
		{
			function();
			astFactory.addASTChild(ref currentAST, returnAST);
			expression_AST = currentAST.root;
			break;
		}
		case IDENT:
		case STRING_LITERAL:
		{
			term();
			astFactory.addASTChild(ref currentAST, returnAST);
			expression_AST = currentAST.root;
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		 }
		returnAST = expression_AST;
	}
	
	public void boost() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST boost_AST = null;
		
		match(CARET);
		num();
		astFactory.addASTChild(ref currentAST, returnAST);
		boost_AST = currentAST.root;
		returnAST = boost_AST;
	}
	
	public void function() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST function_AST = null;
		
		match(HASH);
		{
			switch ( LA(1) )
			{
			case LITERAL_injectmeta:
			{
				injectMetaFunction();
				astFactory.addASTChild(ref currentAST, returnAST);
				break;
			}
			case LITERAL_similarto:
			{
				similarToFunction();
				astFactory.addASTChild(ref currentAST, returnAST);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			 }
		}
		function_AST = currentAST.root;
		returnAST = function_AST;
	}
	
	public void term() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST term_AST = null;
		AST q_AST = null;
		AST u_AST = null;
		AST r_AST = null;
		AST f_AST = null;
		
		{
			if ((LA(1)==IDENT) && (LA(2)==COLON) && (LA(3)==IDENT||LA(3)==STRING_LITERAL))
			{
				qualifiedTerm();
				q_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				term_AST = (AST)currentAST.root;
				term_AST = (AST) astFactory.make(astFactory.create(QUALIFIEDTERM,"QUALIFIEDTERM"), term_AST);
				currentAST.root = term_AST;
				if ( (null != term_AST) && (null != term_AST.getFirstChild()) )
					currentAST.child = term_AST.getFirstChild();
				else
					currentAST.child = term_AST;
				currentAST.advanceChildToEnd();
			}
			else if ((LA(1)==IDENT||LA(1)==STRING_LITERAL) && (tokenSet_4_.member(LA(2)))) {
				unqualifiedTerm();
				u_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				term_AST = (AST)currentAST.root;
				term_AST = (AST) astFactory.make(astFactory.create(UNQUALIFIEDTERM,"UNQUALIFIEDTERM"), term_AST);
				currentAST.root = term_AST;
				if ( (null != term_AST) && (null != term_AST.getFirstChild()) )
					currentAST.child = term_AST.getFirstChild();
				else
					currentAST.child = term_AST;
				currentAST.advanceChildToEnd();
			}
			else if ((LA(1)==IDENT) && (LA(2)==COLON) && (LA(3)==OPEN_SQUARE)) {
				range();
				r_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				term_AST = (AST)currentAST.root;
				term_AST = (AST) astFactory.make(astFactory.create(RANGE,"RANGE"), term_AST);
				currentAST.root = term_AST;
				if ( (null != term_AST) && (null != term_AST.getFirstChild()) )
					currentAST.child = term_AST.getFirstChild();
				else
					currentAST.child = term_AST;
				currentAST.advanceChildToEnd();
			}
			else
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		{
			switch ( LA(1) )
			{
			case TILDE:
			{
				fuzzy();
				f_AST = (AST)returnAST;
				astFactory.addASTChild(ref currentAST, returnAST);
				break;
			}
			case EOF:
			case AND:
			case OR:
			case PLUS:
			case MINUS:
			case OPEN_PAREN:
			case CLOSE_PAREN:
			case CARET:
			case HASH:
			case IDENT:
			case STRING_LITERAL:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			 }
		}
		term_AST = currentAST.root;
		returnAST = term_AST;
	}
	
	public void num() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST num_AST = null;
		
		switch ( LA(1) )
		{
		case NUM_INT:
		{
			AST tmp10_AST = null;
			tmp10_AST = astFactory.create(LT(1));
			astFactory.addASTChild(ref currentAST, tmp10_AST);
			match(NUM_INT);
			num_AST = currentAST.root;
			break;
		}
		case NUM_DOUBLE:
		{
			AST tmp11_AST = null;
			tmp11_AST = astFactory.create(LT(1));
			astFactory.addASTChild(ref currentAST, tmp11_AST);
			match(NUM_DOUBLE);
			num_AST = currentAST.root;
			break;
		}
		case NUM_FLOAT:
		{
			AST tmp12_AST = null;
			tmp12_AST = astFactory.create(LT(1));
			astFactory.addASTChild(ref currentAST, tmp12_AST);
			match(NUM_FLOAT);
			num_AST = currentAST.root;
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		 }
		returnAST = num_AST;
	}
	
	public void fuzzy() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST fuzzy_AST = null;
		
		match(TILDE);
		num();
		astFactory.addASTChild(ref currentAST, returnAST);
		fuzzy_AST = (AST)currentAST.root;
		fuzzy_AST = (AST) astFactory.make(astFactory.create(FUZZY,"FUZZY"), fuzzy_AST);
		currentAST.root = fuzzy_AST;
		if ( (null != fuzzy_AST) && (null != fuzzy_AST.getFirstChild()) )
			currentAST.child = fuzzy_AST.getFirstChild();
		else
			currentAST.child = fuzzy_AST;
		currentAST.advanceChildToEnd();
		fuzzy_AST = currentAST.root;
		returnAST = fuzzy_AST;
	}
	
	public void injectMetaFunction() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST injectMetaFunction_AST = null;
		AST source_AST = null;
		IToken  dest = null;
		AST dest_AST = null;
		
		match(LITERAL_injectmeta);
		match(OPEN_PAREN);
		providerReference();
		source_AST = (AST)returnAST;
		astFactory.addASTChild(ref currentAST, returnAST);
		match(COMMA);
		dest = LT(1);
		dest_AST = astFactory.create(dest);
		astFactory.addASTChild(ref currentAST, dest_AST);
		match(IDENT);
		match(CLOSE_PAREN);
		injectMetaFunction_AST = (AST)currentAST.root;
		injectMetaFunction_AST = (AST) astFactory.make(astFactory.create(INJECTMETA,"INJECTMETA"), injectMetaFunction_AST);
		currentAST.root = injectMetaFunction_AST;
		if ( (null != injectMetaFunction_AST) && (null != injectMetaFunction_AST.getFirstChild()) )
			currentAST.child = injectMetaFunction_AST.getFirstChild();
		else
			currentAST.child = injectMetaFunction_AST;
		currentAST.advanceChildToEnd();
		injectMetaFunction_AST = currentAST.root;
		returnAST = injectMetaFunction_AST;
	}
	
	public void similarToFunction() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST similarToFunction_AST = null;
		AST q_AST = null;
		
		match(LITERAL_similarto);
		match(OPEN_PAREN);
		query();
		q_AST = (AST)returnAST;
		astFactory.addASTChild(ref currentAST, returnAST);
		match(CLOSE_PAREN);
		similarToFunction_AST = (AST)currentAST.root;
		similarToFunction_AST = (AST) astFactory.make(astFactory.create(SIMILARTO,"SIMILARTO"), similarToFunction_AST);
		currentAST.root = similarToFunction_AST;
		if ( (null != similarToFunction_AST) && (null != similarToFunction_AST.getFirstChild()) )
			currentAST.child = similarToFunction_AST.getFirstChild();
		else
			currentAST.child = similarToFunction_AST;
		currentAST.advanceChildToEnd();
		similarToFunction_AST = currentAST.root;
		returnAST = similarToFunction_AST;
	}
	
	public void providerReference() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST providerReference_AST = null;
		IToken  provider = null;
		AST provider_AST = null;
		IToken  key = null;
		AST key_AST = null;
		
		provider = LT(1);
		provider_AST = astFactory.create(provider);
		match(IDENT);
		match(COLON);
		key = LT(1);
		key_AST = astFactory.create(key);
		match(IDENT);
		providerReference_AST = (AST)currentAST.root;
		providerReference_AST = (AST) astFactory.make(astFactory.create(REF,"REF"), provider_AST, key_AST);
		currentAST.root = providerReference_AST;
		if ( (null != providerReference_AST) && (null != providerReference_AST.getFirstChild()) )
			currentAST.child = providerReference_AST.getFirstChild();
		else
			currentAST.child = providerReference_AST;
		currentAST.advanceChildToEnd();
		returnAST = providerReference_AST;
	}
	
	public void qualifiedTerm() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST qualifiedTerm_AST = null;
		
		fieldname();
		astFactory.addASTChild(ref currentAST, returnAST);
		match(COLON);
		{
			switch ( LA(1) )
			{
			case STRING_LITERAL:
			{
				AST tmp23_AST = null;
				tmp23_AST = astFactory.create(LT(1));
				astFactory.addASTChild(ref currentAST, tmp23_AST);
				match(STRING_LITERAL);
				break;
			}
			case IDENT:
			{
				AST tmp24_AST = null;
				tmp24_AST = astFactory.create(LT(1));
				astFactory.addASTChild(ref currentAST, tmp24_AST);
				match(IDENT);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			 }
		}
		qualifiedTerm_AST = currentAST.root;
		returnAST = qualifiedTerm_AST;
	}
	
	public void unqualifiedTerm() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST unqualifiedTerm_AST = null;
		
		switch ( LA(1) )
		{
		case STRING_LITERAL:
		{
			AST tmp25_AST = null;
			tmp25_AST = astFactory.create(LT(1));
			astFactory.addASTChild(ref currentAST, tmp25_AST);
			match(STRING_LITERAL);
			unqualifiedTerm_AST = currentAST.root;
			break;
		}
		case IDENT:
		{
			AST tmp26_AST = null;
			tmp26_AST = astFactory.create(LT(1));
			astFactory.addASTChild(ref currentAST, tmp26_AST);
			match(IDENT);
			unqualifiedTerm_AST = currentAST.root;
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		 }
		returnAST = unqualifiedTerm_AST;
	}
	
	public void range() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST range_AST = null;
		AST from_AST = null;
		AST to_AST = null;
		
		fieldname();
		astFactory.addASTChild(ref currentAST, returnAST);
		match(COLON);
		match(OPEN_SQUARE);
		unqualifiedTerm();
		from_AST = (AST)returnAST;
		astFactory.addASTChild(ref currentAST, returnAST);
		match(TO);
		unqualifiedTerm();
		to_AST = (AST)returnAST;
		astFactory.addASTChild(ref currentAST, returnAST);
		match(CLOSE_SQUARE);
		range_AST = currentAST.root;
		returnAST = range_AST;
	}
	
	public void fieldname() //throws RecognitionException, TokenStreamException
{
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST fieldname_AST = null;
		
		AST tmp31_AST = null;
		tmp31_AST = astFactory.create(LT(1));
		astFactory.addASTChild(ref currentAST, tmp31_AST);
		match(IDENT);
		fieldname_AST = currentAST.root;
		returnAST = fieldname_AST;
	}
	
	private void initializeFactory()
	{
		if (astFactory == null)
		{
			astFactory = new ASTFactory();
		}
		initializeASTFactory( astFactory );
	}
	static public void initializeASTFactory( ASTFactory factory )
	{
		factory.setMaxNodeType(46);
	}
	
	public static readonly string[] tokenNames_ = new string[] {
		@"""<0>""",
		@"""EOF""",
		@"""<2>""",
		@"""NULL_TREE_LOOKAHEAD""",
		@"""CLAUSE""",
		@"""TERM""",
		@"""PREFIX""",
		@"""BOOST""",
		@"""FUZZY""",
		@"""RANGE""",
		@"""QUALIFIEDTERM""",
		@"""UNQUALIFIEDTERM""",
		@"""INJECTMETA""",
		@"""SIMILARTO""",
		@"""EXPANDSYNONYMS""",
		@"""REF""",
		@"""AND""",
		@"""OR""",
		@"""PLUS""",
		@"""MINUS""",
		@"""OPEN_PAREN""",
		@"""CLOSE_PAREN""",
		@"""CARET""",
		@"""TILDE""",
		@"""HASH""",
		@"""injectmeta""",
		@"""COMMA""",
		@"""IDENT""",
		@"""similarto""",
		@"""COLON""",
		@"""STRING_LITERAL""",
		@"""NUM_INT""",
		@"""NUM_DOUBLE""",
		@"""NUM_FLOAT""",
		@"""OPEN_SQUARE""",
		@"""TO""",
		@"""CLOSE_SQUARE""",
		@"""NOT""",
		@"""DOLLAR""",
		@"""WS""",
		@"""CHAR_LITERAL""",
		@"""ESC""",
		@"""HEX_DIGIT""",
		@"""EXPONENT""",
		@"""FLOAT_SUFFIX""",
		@"""NUM_LONG""",
		@"""DOT"""
	};
	
	private static long[] mk_tokenSet_0_()
	{
		long[] data = { 1226571776L, 0L};
		return data;
	}
	public static readonly BitSet tokenSet_0_ = new BitSet(mk_tokenSet_0_());
	private static long[] mk_tokenSet_1_()
	{
		long[] data = { 1233059842L, 0L};
		return data;
	}
	public static readonly BitSet tokenSet_1_ = new BitSet(mk_tokenSet_1_());
	private static long[] mk_tokenSet_2_()
	{
		long[] data = { 17112694786L, 0L};
		return data;
	}
	public static readonly BitSet tokenSet_2_ = new BitSet(mk_tokenSet_2_());
	private static long[] mk_tokenSet_3_()
	{
		long[] data = { 34292563970L, 0L};
		return data;
	}
	public static readonly BitSet tokenSet_3_ = new BitSet(mk_tokenSet_3_());
	private static long[] mk_tokenSet_4_()
	{
		long[] data = { 1241448450L, 0L};
		return data;
	}
	public static readonly BitSet tokenSet_4_ = new BitSet(mk_tokenSet_4_());
	
}
}
